package com.promise.jokerdream.work

import kotlinx.coroutines.*
import java.util.*
import java.util.concurrent.atomic.AtomicBoolean
import com.promise.jokerdream.manager.ExecutionHistoryManager
import com.promise.jokerdream.utils.AppContext
import com.promise.jokerdream.JokerDreamApplication

/**
 * 工作管理器基类
 * 负责管理和执行IWork，按优先级顺序执行，同一时间只执行一个work
 */
abstract class BaseWorkManager {
    
    // 使用优先队列存储work，按优先级排序（数值越小优先级越高）
    private val workQueue = PriorityQueue<IWork> { work1: IWork, work2: IWork ->
        work1.priority.compareTo(work2.priority)
    }
    
    // 标记是否正在执行work
    private val isExecuting = AtomicBoolean(false)
    
    /**
     * 检查是否有正在运行的任务
     */
    fun hasRunningTasks(): Boolean {
        return isExecuting.get()
    }
    
    /**
     * 获取当前队列中的任务数量
     */
    fun getQueueSize(): Int {
        return synchronized(workQueue) {
            workQueue.size
        }
    }
    
    // 使用全局协程作用域，确保应用进入后台后仍能执行
    private val scope: CoroutineScope by lazy {
        (AppContext.get() as? JokerDreamApplication)?.applicationScope
            ?: CoroutineScope(Dispatchers.Default + SupervisorJob())
    }
    
    // 当前执行的任务协程
    private var currentExecutionJob: Job? = null
    
    // 日志管理器
    private val historyManager by lazy { ExecutionHistoryManager.getInstance(AppContext.get()) }
    
    /**
     * 添加工作到队列
     */
    fun addWork(work: IWork) {
        synchronized(workQueue) {
            workQueue.offer(work)
        }
        // 如果当前没有在执行，则开始执行
        if (!isExecuting.get()) {
            startExecution()
        }
    }
    
    /**
     * 批量添加工作
     */
    fun addWorks(works: List<IWork>) {
        synchronized(workQueue) {
            works.forEach { work: IWork -> workQueue.offer(work) }
        }
        // 如果当前没有在执行，则开始执行
        if (!isExecuting.get()) {
            startExecution()
        }
    }
    
    /**
     * 清空队列
     */
    fun clearQueue() {
        synchronized(workQueue) {
            workQueue.clear()
        }
    }
    
    /**
     * 取消所有任务（包括正在执行的任务）
     */
    fun cancelAllTasks() {
        // 清空队列
        clearQueue()
        
        // 取消当前执行的任务
        currentExecutionJob?.cancel()
        currentExecutionJob = null
        
        // 重置执行状态
        isExecuting.set(false)
        
        historyManager.addHistory(getManagerName(), "所有任务已取消")
    }
    
    /**
     * 开始执行队列中的work
     */
    private fun startExecution() {
        if (isExecuting.compareAndSet(false, true)) {
            currentExecutionJob = scope.launch {
                executeWorks()
            }
        }
    }
    
    /**
     * 按优先级顺序执行work
     */
    private suspend fun executeWorks() {
        try {
            while (true) {
                // 检查协程是否被取消
                if (currentExecutionJob?.isActive != true) {
                    break
                }
                
                val work: IWork = synchronized(workQueue) {
                    workQueue.poll()
                } ?: break // 队列为空，退出循环
                
                try {
                    println("开始执行工作: ${work.name}, 优先级: ${work.priority}")
                    historyManager.addHistory(getManagerName(), "开始执行工作: ${work.name}")
                    
                    val result = work.executeWork()
                    when (result) {
                        is WorkResult.Success -> {
                            println("工作执行成功: ${work.name}")
                        }
                        is WorkResult.Failure -> {
                            println("工作执行失败: ${work.name}, 错误: ${result.message}")
                        }
                        is WorkResult.Cancelled -> {
                            println("工作执行被取消: ${work.name}")
                        }
                    }
                } catch (e: Exception) {
                    if (e is kotlinx.coroutines.CancellationException) {
                        println("工作执行被取消: ${work.name}")
                        break
                    } else {
                        println("工作执行异常: ${work.name}, 错误: ${e.message}")
                        e.printStackTrace()
                    }
                }
            }
        } finally {
            isExecuting.set(false)
            currentExecutionJob = null
            // 记录工作队列执行完成
            historyManager.addHistory(getManagerName(), "工作队列执行完成")
            
            // 调用子类的执行完成钩子
            onExecutionCompleted()
            
            // 检查是否有新的work被添加
            synchronized(workQueue) {
                if (workQueue.isNotEmpty()) {
                    startExecution()
                }
            }
        }
    }
    
    /**
     * 关闭WorkManager，取消所有正在进行的协程
     * 注意：不会取消全局协程作用域，只取消当前管理器的任务
     */
    fun shutdown() {
        cancelAllTasks()
        // 不取消全局协程作用域，因为其他管理器可能还在使用
    }
    
    // ========== 抽象方法，子类需要实现 ==========
    
    /**
     * 获取管理器名称，用于日志记录
     */
    abstract fun getManagerName(): String
    
    /**
     * 执行完成后的钩子方法
     * 子类可以重写此方法来实现执行完成后的逻辑（如更新状态等）
     */
    protected open suspend fun onExecutionCompleted() {
        // 默认实现为空，子类可以重写
    }
}
